home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / src / gdb-4.12 / sim / sh / gencode.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-03  |  20.0 KB  |  728 lines
  1. /* Simulator/Opcode generator for the Hitachi Super-H architecture.
  2.  
  3.    Written by Steve Chamberlain of Cygnus Support.
  4.    sac@cygnus.com
  5.  
  6.    This file is part of SH sim
  7.  
  8.  
  9.         THIS SOFTWARE IS NOT COPYRIGHTED
  10.  
  11.    Cygnus offers the following for use in the public domain.  Cygnus
  12.    makes no warranty with regard to the software or it's performance
  13.    and the user accepts the software "AS IS" with all faults.
  14.  
  15.    CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
  16.    THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17.    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18.  
  19. */
  20.  
  21. /* This program generates the opcode table for the assembler and
  22.    the simulator code
  23.  
  24.    -t        prints a pretty table for the assembler manual
  25.    -s        generates the simulator code jump table
  26.    -x        generates the simulator code switch statement
  27.    default     generates the opcode tables
  28.  
  29. */
  30.  
  31. #include <stdio.h>
  32.  
  33. typedef struct
  34. {
  35.   char *name;
  36.   char *code;
  37.   char *stuff[10];
  38.   int index;
  39. }
  40.  
  41. op;
  42.  
  43.  
  44. op tab[] =
  45. {
  46.  
  47.   {"add #<imm>,<REG_N>", "0111nnnni8*1....", "R[n] += SEXT(i);"},
  48.   {"add <REG_M>,<REG_N>", "0011nnnnmmmm1100", "R[n] += R[m];"},
  49.   {"addc <REG_M>,<REG_N>", "0011nnnnmmmm1110", "ult = R[n]; R[n] += (R[m]+T); T = ult>R[n];"},
  50.   {"addv <REG_M>,<REG_N>", "0011nnnnmmmm1111",
  51.    "{long ans;",
  52.    "ans = R[n] + R[m];",
  53.    "T = ((~R[n] & R[m] & ans) | (R[n] & R[m] & ~ans)) >>31;",
  54.    "R[n] = ans;}"},
  55.  
  56.   {"and #<imm>,R0", "11001001i8*1....", "R0&=i;"},
  57.   {"and <REG_M>,<REG_N>", "0010nnnnmmmm1001", "R[n]&=R[m];"},
  58.   {"and.b #<imm>,@(R0,GBR)", "11001101i8*1....", "WBAT(GBR+R0, RBAT(GBR+R0) & i);"},
  59.  
  60.  
  61. {"bra <bdisp12>", "1010i12.........", "ult = PC; PC=PC+(i<<1)+2;SL(ult+2);"},
  62.   {"bsr <bdisp12>", "1011i12.........", "PR = PC; PC=PC+(i<<1)+2;SL(PR+2);"},
  63.   {"bt <bdisp8>", "10001001i8p1....", "if(T) {PC+=(SEXT(i)<<1)+2;C+=2;}"},
  64.   {"bf <bdisp8>", "10001011i8p1....", "if(T==0) {PC+=(SEXT(i)<<1)+2;C+=2;}"},
  65.   {"bt.s <bdisp8>", "10001101i8p1....","if(T) {ult = PC; PC+=(SEXT(i)<<1)+2;C+=2;SL(ult+2);}"},
  66.   {"bf.s <bdisp8>", "10001111i8p1....","if(!T) {ult = PC; PC+=(SEXT(i)<<1)+2;C+=2;SL(ult+2);}"},
  67.   {"clrmac", "0000000000101000", "MACH = MACL = 0;"},
  68.   {"clrt", "0000000000001000", "T= 0;"},
  69.   {"cmp/eq #<imm>,R0", "10001000i8*1....", "T = R0 == SEXT(i);"},
  70.   {"cmp/eq <REG_M>,<REG_N>", "0011nnnnmmmm0000", "T=R[n]==R[m];"},
  71.   {"cmp/ge <REG_M>,<REG_N>", "0011nnnnmmmm0011", "T=R[n]>=R[m];"},
  72.   {"cmp/gt <REG_M>,<REG_N>", "0011nnnnmmmm0111", "T=R[n]>R[m];"},
  73.   {"cmp/hi <REG_M>,<REG_N>", "0011nnnnmmmm0110", "T=UR[n]>UR[m];"},
  74.   {"cmp/hs <REG_M>,<REG_N>", "0011nnnnmmmm0010", "T=UR[n]>=UR[m];"},
  75.   {"cmp/pl <REG_N>", "0100nnnn00010101", "T = R[n]>0;"},
  76.   {"cmp/pz <REG_N>", "0100nnnn00010001", "T = R[n]>=0;"},
  77.   {"cmp/str <REG_M>,<REG_N>", "0010nnnnmmmm1100",
  78.    "ult = R[n] ^ R[m]; T=((ult&0xff000000)==0) |((ult&0xff0000)==0) |((ult&0xff00)==0) |((ult&0xff)==0); "},
  79.   {"div0s <REG_M>,<REG_N>", "0010nnnnmmmm0111", "Q=(R[n]&sbit)!=0; M=(R[m]&sbit)!=0; T=M!=Q;;"},
  80.   {"div0u", "0000000000011001", "M=Q=T=0;"},
  81.   {"div1 <REG_M>,<REG_N>", "0011nnnnmmmm0100", "T=div1(R,m,n,T);"},
  82.   {"exts.b <REG_M>,<REG_N>", "0110nnnnmmmm1110", "R[n] = SEXT(R[m]);"},
  83.   {"exts.w <REG_M>,<REG_N>", "0110nnnnmmmm1111", "R[n] = SEXTW(R[m]);"},
  84.   {"extu.b <REG_M>,<REG_N>", "0110nnnnmmmm1100", "R[n] = R[m] & 0xff;"},
  85.   {"extu.w <REG_M>,<REG_N>", "0110nnnnmmmm1101", "R[n] = R[m] & 0xffff;"},
  86.   {"jmp @<REG_N>", "0100nnnn00101011", "ult = PC; PC=R[n]-2; SL(ult+2);"},
  87.   {"jsr @<REG_N>", "0100nnnn00001011", "PR = PC; PC=R[n]-2; if (~doprofile) gotcall(PR,PC+2);SL(PR+2);"},
  88.   {"ldc <REG_N>,GBR", "0100nnnn00011110", "GBR=R[n];"},
  89.   {"ldc <REG_N>,SR", "0100nnnn00001110", "SET_SR(R[n]);"},
  90.   {"ldc <REG_N>,VBR", "0100nnnn00101110", "VBR=R[n];"},
  91.   {"ldc.l @<REG_N>+,GBR", "0100nnnn00010111", "GBR=RLAT(R[n]);R[n]+=4;;"},
  92.   {"ldc.l @<REG_N>+,SR", "0100nnnn00000111", "SET_SR(RLAT(R[n]));R[n]+=4;;"},
  93.   {"ldc.l @<REG_N>+,VBR", "0100nnnn00100111", "VBR=RLAT(R[n]);R[n]+=4;;"},
  94.   {"lds <REG_N>,MACH", "0100nnnn00001010", "MACH = SEXT(R[n]);"},
  95.   {"lds <REG_N>,MACL", "0100nnnn00011010", "MACL= R[n];"},
  96.   {"lds <REG_N>,PR", "0100nnnn00101010", "PR = R[n];"},
  97.   {"lds.l @<REG_N>+,MACH", "0100nnnn00000110", "MACH = SEXT(RLAT(R[n]));R[n]+=4;"},
  98.   {"lds.l @<REG_N>+,MACL", "0100nnnn00010110", "MACL = RLAT(R[n]);R[n]+=4;"},
  99.   {"lds.l @<REG_N>+,PR", "0100nnnn00100110", "PR = RLAT(R[n]);R[n]+=4;;"},
  100.   {"mac.w @<REG_M>+,@<REG_N>+", "0100nnnnmmmm1111", "abort();"},
  101.   {"mov #<imm>,<REG_N>", "1110nnnni8*1....", "R[n] = SEXT(i);"},
  102.   {"mov <REG_M>,<REG_N>", "0110nnnnmmmm0011", "R[n] = R[m];"},
  103. {"mov.b <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0100", "WBAT(R[n]+R0, R[m]);"},
  104. {"mov.b <REG_M>,@-<REG_N>", "0010nnnnmmmm0100", "R[n]--; WBAT(R[n],R[m]);"},
  105.   {"mov.b <REG_M>,@<REG_N>", "0010nnnnmmmm0000", "WBAT(R[n], R[m]);"},
  106.   {"mov.b @(<disp>,<REG_M>),R0", "10000100mmmmi4*1", "R0=RSBAT(i+R[m]);L(0);"},
  107.   {"mov.b @(<disp>,GBR),R0", "11000100i8*1....", "R0=RSBAT(i+GBR);L(0);"},
  108.   {"mov.b @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1100", "R[n]=RSBAT(R0+R[m]);L(n);"},
  109.   {"mov.b @<REG_M>+,<REG_N>", "0110nnnnmmmm0100", "R[n] = RSBAT(R[m]);L(n);R[m]++;"},
  110.   {"mov.b @<REG_M>,<REG_N>", "0110nnnnmmmm0000", "R[n]=RSBAT(R[m]);L(n);"},
  111.   {"mov.b R0,@(<disp>,<REG_M>)", "10000000mmmmi4*1", "R0=RSBAT(i+R[m]);L(0);"},
  112.   {"mov.b R0,@(<disp>,GBR)", "11000000i8*1....", "R0 = RSBAT(i+GBR);L(0);"},
  113.   {"mov.l <REG_M>,@(<disp>,<REG_N>)", "0001nnnnmmmmi4*4",
  114.    "WLAT(i+R[n],R[m]);"},
  115.   {"mov.l <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0110", "WLAT(R0+R[n],R[m]);"},
  116. {"mov.l <REG_M>,@-<REG_N>", "0010nnnnmmmm0110", "R[n]-=4;WLAT(R[n],R[m]);"},
  117.   {"mov.l <REG_M>,@<REG_N>", "0010nnnnmmmm0010", "WLAT(R[n], R[m]);"},
  118.   {"mov.l @(<disp>,<REG_M>),<REG_N>","0101nnnnmmmmi4*4", "R[n]=RLAT(i+R[m]);L(n);"},
  119.   {"mov.l @(<disp>,GBR),R0", "11000110i4*4", "R0=RLAT(i+GBR);L(0);"},
  120.   {"mov.l @(<disp>,PC),<REG_N>", "1101nnnni8p4....", "R[n]=RLAT(i+4+PC);L(n);"},
  121.   {"mov.l @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1110", "R[n]=RLAT(R0+R[m]);L(n);"},
  122. {"mov.l @<REG_M>+,<REG_N>", "0110nnnnmmmm0110", "R[n]=RLAT(R[m]);R[m]+=4;L(n);"},
  123.   {"mov.l @<REG_M>,<REG_N>", "0110nnnnmmmm0010", "R[n]=RLAT(R[m]);L(n);"},
  124.   {"mov.l R0,@(<disp>,GBR)", "11000010i8*4....", "R0=RLAT(R0+GBR);L(0);"},
  125.   {"mov.w <REG_M>,@(R0,<REG_N>)", "0000nnnnmmmm0101", "WWAT(R0+R[n],R[m]);"},
  126. {"mov.w <REG_M>,@-<REG_N>", "0010nnnnmmmm0101", "R[n]-=2;WWAT(R[n],R[m]);"},
  127.   {"mov.w <REG_M>,@<REG_N>", "0010nnnnmmmm0001", "WWAT(R[n],R[m]);"},
  128.   {"mov.w @(<disp>,<REG_M>),R0", "10000101mmmmi4*2", "R0=RSWAT(i+R[m]);L(0);"},
  129.   {"mov.w @(<disp>,GBR),R0", "11000101i8*2....", "R0=RSWAT(i+GBR);L(0);"},
  130.   {"mov.w @(<disp>,PC),<REG_N>", "1001nnnni8p2....", "R[n]=RSWAT(PC+i+4);L(n);"},
  131. {"mov.w @(R0,<REG_M>),<REG_N>", "0000nnnnmmmm1101", "R[n]=RSWAT(R0+R[m]);L(n);"},
  132. {"mov.w @<REG_M>+,<REG_N>", "0110nnnnmmmm0101", "R[n]=RSWAT(R[m]);R[m]+=2;L(n);"},
  133.   {"mov.w @<REG_M>,<REG_N>", "0110nnnnmmmm0001", "R[n]=RSWAT(R[m]);L(n);"},
  134.   {"mov.w R0,@(<disp>,<REG_M>)", "10000001mmmmi4*2",   "R0=RSWAT(i+R[m]);L(0);"},
  135.   {"mov.w R0,@(<disp>,GBR)", "11000001i8*2....", "R0=RSWAT(i+GBR);L(0);"},
  136.   {"mova @(<disp>,PC),R0", "11000111i8p4....", "R0=((i+4+PC) & ~0x3);"},
  137.   {"movt <REG_N>", "0000nnnn00101001", "R[n]=T;"},
  138.   {"muls <REG_M>,<REG_N>", "0010nnnnmmmm1111","MACL=((int)(short)R[n])*((int)(short)R[m]);"},
  139.   {"mul.l <REG_M>,<REG_N>","0000nnnnmmmm0111","MACL=((int)R[n])*((int)R[m]);"},
  140.   {"mulu <REG_M>,<REG_N>", "0010nnnnmmmm1110","MACL=((unsigned int)(unsigned short)R[n])*((unsigned int)(unsigned short)R[m]);"},
  141.   {"neg <REG_M>,<REG_N>", "0110nnnnmmmm1011", "R[n] = - R[m];"},
  142.   {"negc <REG_M>,<REG_N>", "0110nnnnmmmm1010",
  143.    "ult=0-R[m];R[n]=ult-T;T=SBIT(R[n])!=SBIT(ult);"},
  144.   {"nop", "0000000000001001", ""},
  145.   {"not <REG_M>,<REG_N>", "0110nnnnmmmm0111", "R[n]=~R[m];"},
  146.   {"or #<imm>,R0", "11001011i8*1....", "R0|=i;"},
  147.   {"or <REG_M>,<REG_N>", "0010nnnnmmmm1011", "R[n]|=R[m];"},
  148.   {"or.b #<imm>,@(R0,GBR)", "11001111i8*1....", "WBAT(R0+GBR,RBAT(R0+GBR)|i);"},
  149. {"rotcl <REG_N>", "0100nnnn00100100", "ult=R[n]<0;R[n]=(R[n]<<1)|T;T=ult;"},
  150.   {"rotcr <REG_N>", "0100nnnn00100101", "ult=R[n]&1;R[n]=(UR[n]>>1)|(T<<31);T=ult;"},
  151.   {"rotl <REG_N>", "0100nnnn00000100", "T=R[n]<0;R[n]<<=1;R[n]|=T;"},
  152.   {"rotr <REG_N>", "0100nnnn00000101", "T=R[n]&1;R[n] = UR[n]>> 1;R[n]|=(T<<31);"},
  153.   {"rte", "0000000000101011", "abort();"},
  154.   {"rts", "0000000000001011", "ult=PC;PC=PR+2;SL(ult+2);"},
  155.   {"sett", "0000000000011000", "T=1;"},
  156.   {"shal <REG_N>", "0100nnnn00100000", "T=R[n]<0; R[n]<<=1;"},
  157.   {"shar <REG_N>", "0100nnnn00100001", "T=R[n]&1; R[n] = R[n] >> 1;"},
  158.   {"shll <REG_N>", "0100nnnn00000000", "T=R[n]<0; R[n]<<=1;"},
  159.   {"shll16 <REG_N>", "0100nnnn00101000", "R[n]<<=16;"},
  160.   {"shll2 <REG_N>", "0100nnnn00001000", "R[n]<<=2;"},
  161.   {"shll8 <REG_N>", "0100nnnn00011000", "R[n]<<=8;"},
  162.   {"shlr <REG_N>", "0100nnnn00000001", "T=R[n]&1;R[n]=UR[n]>>1;"},
  163.   {"shlr16 <REG_N>", "0100nnnn00101001", "R[n]=UR[n]>>16;"},
  164.   {"shlr2 <REG_N>", "0100nnnn00001001", "R[n]=UR[n]>>2;"},
  165.   {"shlr8 <REG_N>", "0100nnnn00011001", "R[n]=UR[n]>>8;"},
  166.   {"sleep", "0000000000011011", "abort();"},
  167.   {"stc GBR,<REG_N>", "0000nnnn00010010", "R[n]=GBR;"},
  168.   {"stc SR,<REG_N>", "0000nnnn00000010", "R[n]=GET_SR();"},
  169.   {"stc VBR,<REG_N>", "0000nnnn00100010", "R[n]=VBR;"},
  170.   {"stc.l GBR,@-<REG_N>", "0100nnnn00010011", "R[n]-=4;WLAT(R[n],GBR);;"},
  171.   {"stc.l SR,@-<REG_N>", "0100nnnn00000011", "R[n]-=4;WLAT(R[n],GET_SR());"},
  172.   {"stc.l VBR,@-<REG_N>", "0100nnnn00100011", "R[n]-=4;WLAT(R[n],VBR);"},
  173.   {"sts MACH,<REG_N>", "0000nnnn00001010", "R[n]=MACH;"},
  174.   {"sts MACL,<REG_N>", "0000nnnn00011010", "R[n]=MACL;"},
  175.   {"sts PR,<REG_N>", "0000nnnn00101010", "R[n]=PR;"},
  176.   {"sts.l MACH,@-<REG_N>", "0100nnnn00000010", "R[n]-=4;WLAT(R[n],MACH);"},
  177.   {"sts.l MACL,@-<REG_N>", "0100nnnn00010010", "R[n]-=4;WLAT(R[n],MACL);"},
  178.   {"sts.l PR,@-<REG_N>", "0100nnnn00100010", "R[n]-=4;WLAT(R[n],PR);"},
  179.   {"sub <REG_M>,<REG_N>", "0011nnnnmmmm1000", "R[n]-=R[m];"},
  180.   {"subc <REG_M>,<REG_N>", "0011nnnnmmmm1010", "ult = R[n];R[n]-=R[m]+T;T=ult<UR[n];"},
  181.   {"subv <REG_M>,<REG_N>", "0011nnnnmmmm1011", "abort();"},
  182.   {"swap.b <REG_M>,<REG_N>", "0110nnnnmmmm1000", "R[n]=((R[m]<<8)&0xff00)|((R[m]>>8)&0x00ff);"},
  183.   {"swap.w <REG_M>,<REG_N>", "0110nnnnmmmm1001", "R[n]=((R[m]<<16)&0xffff0000)|((R[m]>>16)&0x00ffff);"},
  184.   {"tas.b @<REG_N>", "0100nnnn00011011", "ult=RBAT(R[n]);T=ult==0;WBAT(R[n],ult|0x80);"},
  185.   {"trapa #<imm>", "11000011i8*1....", "trap(i,R);"},
  186.   {"tst #<imm>,R0", "11001000i8*1....", "T=(R0&i)==0;"},
  187.   {"tst <REG_M>,<REG_N>", "0010nnnnmmmm1000", "T=(R[n]&R[m])==0;"},
  188.   {"tst.b #<imm>,@(R0,GBR)", "11001100i8*1....", "T=(RBAT(GBR+R0)&i)==0;"},
  189.   {"xor #<imm>,R0", "11001010i8*1....", "R0^=i;"},
  190.   {"xor <REG_M>,<REG_N>", "0010nnnnmmmm1010", "R[n]^=R[m];"},
  191.   {"xor.b #<imm>,@(R0,GBR)", "11001110i8*1....", "ult=RBAT(GBR+R0);ult^=i;WBAT(GBR+R0,ult);"},
  192.   {"xtrct <REG_M>,<REG_N>", "0010nnnnmmmm1101", "R[n]=((R[n]>>16)&0xffff)|((R[m]<<16)&0xffff0000);"},
  193.   {"mul.l <REG_M>,<REG_N>", "0000nnnnmmmm0111", " MACL = R[n] * R[m];"},
  194.   {"dt <REG_N>", "0100nnnn00010000", "R[n]--; T=R[n] == 0;"},
  195.  
  196.  
  197.   {"dmuls.l <REG_M>,<REG_N>", "0011nnnnmmmm1101", "dmul(1,R[n],R[m]);"},
  198.   {"dmulu.l <REG_M>,<REG_N>", "0011nnnnmmmm0101", "dmul(0,R[n],R[m]);"},
  199.   {"mac.l @<REG_M>+,@<REG_N>+", "0000nnnnmmmm1111", ""},
  200. #if 0
  201.   {"braf @<REG_N>", "0000nnnn00100011", ""},
  202.   {"bsrf @<REG_N>", "0000nnnn00000011", ""},
  203.   {"divs.l <REG_M>,<REG_N>", "0100nnnnmmmm1110", "divl(0,R[n],R[m]);"},
  204.   {"divu.l <REG_M>,<REG_N>", "0100nnnnmmmm1101", "divl(0,R[n],R[m]);"},
  205. #endif
  206.  
  207.   {0, 0}};
  208.  
  209. /* Tables of things to put into enums for sh-opc.h */
  210. static char *nibble_type_list[] =
  211. {
  212.   "HEX_0",
  213.   "HEX_1",
  214.   "HEX_2",
  215.   "HEX_3",
  216.   "HEX_4",
  217.   "HEX_5",
  218.   "HEX_6",
  219.   "HEX_7",
  220.   "HEX_8",
  221.   "HEX_9",
  222.   "HEX_A",
  223.   "HEX_B",
  224.   "HEX_C",
  225.   "HEX_D",
  226.   "HEX_E",
  227.   "HEX_F",
  228.   "REG_N",
  229.   "REG_M",
  230.   "BRANCH_12",
  231.   "BRANCH_8",
  232.   "DISP_8",
  233.   "DISP_4",
  234.   "IMM_4",
  235.   "IMM_4BY2",
  236.   "IMM_4BY4",
  237.   "PCRELIMM_8BY2",
  238.   "PCRELIMM_8BY4",
  239.   "IMM_8",
  240.   "IMM_8BY2",
  241.   "IMM_8BY4",
  242.   0
  243. };
  244. static
  245. char *arg_type_list[] =
  246. {
  247.   "A_END",
  248.   "A_BDISP12",
  249.   "A_BDISP8",
  250.   "A_DEC_M",
  251.   "A_DEC_N",
  252.   "A_DISP_GBR",
  253.   "A_DISP_PC",
  254.   "A_DISP_REG_M",
  255.   "A_DISP_REG_N",
  256.   "A_GBR",
  257.   "A_IMM",
  258.   "A_INC_M",
  259.   "A_INC_N",
  260.   "A_IND_M",
  261.   "A_IND_N",
  262.   "A_IND_R0_REG_M",
  263.   "A_IND_R0_REG_N",
  264.   "A_MACH",
  265.   "A_MACL",
  266.   "A_PR",
  267.   "A_R0",
  268.   "A_R0_GBR",
  269.   "A_REG_M",
  270.   "A_REG_N",
  271.   "A_SR",
  272.   "A_VBR",
  273.   0,
  274. };
  275.  
  276. static void
  277. make_enum_list (name, s)
  278.      char *name;
  279.      char **s;
  280. {
  281.   int i = 1;
  282.   printf ("typedef enum {\n");
  283.   while (*s)
  284.     {
  285.       printf ("\t%s,\n", *s);
  286.       s++;
  287.       i++;
  288.     }
  289.   printf ("} %s;\n", name);
  290. }
  291.  
  292. static int
  293. qfunc (a, b)
  294.      op *a;
  295.      op *b;
  296. {
  297.   char bufa[9];
  298.   char bufb[9];
  299.   memcpy (bufa, a->code, 4);
  300.   memcpy (bufa + 4, a->code + 12, 4);
  301.   bufa[8] = 0;
  302.  
  303.   memcpy (bufb, b->code, 4);
  304.   memcpy (bufb + 4, b->code + 12, 4);
  305.   bufb[8] = 0;
  306.   return (strcmp (bufa, bufb));
  307. }
  308.  
  309. static void
  310. sorttab ()
  311. {
  312.   op *p = tab;
  313.   int len = 0;
  314.  
  315.   while (p->name)
  316.     {
  317.       p++;
  318.       len++;
  319.     }
  320.   qsort (tab, len, sizeof (*p), qfunc);
  321. }
  322.  
  323. static void
  324. printonmatch (ptr, a, rep)
  325.      char **ptr;
  326.      char *a;
  327.      char *rep;
  328. {
  329.   int l = strlen (a);
  330.   if (strncmp (*ptr, a, l) == 0)
  331.     {
  332.       printf ("%s", rep);
  333.       *ptr += l;
  334.       if (**ptr)
  335.     printf (",");
  336.     }
  337. }
  338.  
  339.  
  340. static 
  341. void
  342. think (o)
  343.      op *o;
  344. {
  345.   char *n;
  346.   char *p;
  347.  
  348.   printf ("{\"");
  349.   n = o->name;
  350.   while (*n && *n != ' ')
  351.     {
  352.       printf ("%c", *n);
  353.       n++;
  354.     }
  355.   printf ("\",{");
  356.  
  357.   p = n;
  358.  
  359.   if (!*p)
  360.     {
  361.       printf ("0");
  362.     }
  363.   while (*p)
  364.     {
  365.       while (*p == ',' || *p == ' ')
  366.     p++;
  367.       printonmatch (&p, "#<imm>", "A_IMM");
  368.       printonmatch (&p, "R0", "A_R0");
  369.       printonmatch (&p, "<REG_N>", "A_REG_N");
  370.       printonmatch (&p, "@<REG_N>+", "A_INC_N");
  371.       printonmatch (&p, "@<REG_N>", "A_IND_N");
  372.       printonmatch (&p, "@-<REG_N>", "A_DEC_N");
  373.       printonmatch (&p, "<REG_M>", " A_REG_M");
  374.       printonmatch (&p, "@<REG_M>+", "A_INC_M");
  375.       printonmatch (&p, "@<REG_M>", "A_IND_M");
  376.       printonmatch (&p, "@-<REG_M>", "A_DEC_M");
  377.       printonmatch (&p, "@(<disp>,PC)", "A_DISP_PC");
  378.       printonmatch (&p, "@(<disp>,<REG_M>)", "A_DISP_REG_M");
  379.       printonmatch (&p, "@(<disp>,<REG_N>)", "A_DISP_REG_N");
  380.       printonmatch (&p, "@(R0,<REG_N>)", "A_IND_R0_REG_N");
  381.       printonmatch (&p, "@(R0,<REG_M>)", "A_IND_R0_REG_M");
  382.       printonmatch (&p, "@(<disp>,GBR)", "A_DISP_GBR");
  383.       printonmatch (&p, "@(R0,GBR)", "A_R0_GBR");
  384.       printonmatch (&p, "<bdisp8>", "A_BDISP8");
  385.       printonmatch (&p, "<bdisp12>", "A_BDISP12");
  386.       printonmatch (&p, "SR", "A_SR");
  387.       printonmatch (&p, "GBR", "A_GBR");
  388.       printonmatch (&p, "VBR", "A_VBR");
  389.       printonmatch (&p, "MACH", "A_MACH");
  390.       printonmatch (&p, "MACL", "A_MACL");
  391.       printonmatch (&p, "PR", "A_PR");
  392.  
  393.     }
  394.   printf ("},{");
  395.  
  396.   p = o->code;
  397.   while (*p)
  398.     {
  399.       printonmatch (&p, "0000", "HEX_0");
  400.       printonmatch (&p, "0001", "HEX_1");
  401.       printonmatch (&p, "0010", "HEX_2");
  402.       printonmatch (&p, "0011", "HEX_3");
  403.       printonmatch (&p, "0100", "HEX_4");
  404.       printonmatch (&p, "0101", "HEX_5");
  405.       printonmatch (&p, "0110", "HEX_6");
  406.       printonmatch (&p, "0111", "HEX_7");
  407.  
  408.       printonmatch (&p, "1000", "HEX_8");
  409.       printonmatch (&p, "1001", "HEX_9");
  410.       printonmatch (&p, "1010", "HEX_A");
  411.       printonmatch (&p, "1011", "HEX_B");
  412.       printonmatch (&p, "1100", "HEX_C");
  413.       printonmatch (&p, "1101", "HEX_D");
  414.       printonmatch (&p, "1110", "HEX_E");
  415.       printonmatch (&p, "1111", "HEX_F");
  416.       printonmatch (&p, "i8*1....", "IMM_8");
  417.       printonmatch (&p, "i4*1", "IMM_4");
  418.       printonmatch (&p, "i8p4....", "PCRELIMM_8BY4");
  419.       printonmatch (&p, "i8p2....", "PCRELIMM_8BY2");
  420.       printonmatch (&p, "i8*2....", "IMM_8BY2");
  421.       printonmatch (&p, "i4*2", "IMM_4BY2");
  422.       printonmatch (&p, "i8*4....", "IMM_8BY4");
  423.       printonmatch (&p, "i4*4", "IMM_4BY4");
  424.       printonmatch (&p, "i12.........", "BRANCH_12");
  425.       printonmatch (&p, "i8p1....", "BRANCH_8");
  426.       printonmatch (&p, "nnnn", "REG_N");
  427.       printonmatch (&p, "mmmm", "REG_M");
  428.  
  429.     }
  430.   printf ("}},\n");
  431. }
  432.  
  433. static void
  434. gengastab ()
  435. {
  436.   op *p;
  437.   sorttab ();
  438.   for (p = tab; p->name; p++)
  439.     {
  440.       printf ("%s %-30s\n", p->code, p->name);
  441.     }
  442.  
  443.  
  444. }
  445.  
  446.  
  447. static void
  448. genopc ()
  449. {
  450.   op *p;
  451.   make_enum_list ("sh_nibble_type", nibble_type_list);
  452.   make_enum_list ("sh_arg_type", arg_type_list);
  453.  
  454.   printf ("typedef struct {\n");
  455.   printf ("char *name;\n");
  456.   printf ("sh_arg_type arg[3];\n");
  457.   printf ("sh_nibble_type nibbles[4];\n");
  458.   printf ("} sh_opcode_info;\n");
  459.   printf ("#ifdef DEFINE_TABLE\n");
  460.   printf ("sh_opcode_info sh_table[]={\n");
  461.   for (p = tab; p->name; p++)
  462.     {
  463.       printf ("\n\/\* %s %-20s*/", p->code, p->name);
  464.       think (p);
  465.     }
  466.   printf ("0};\n");
  467.   printf ("#endif\n");
  468. }
  469.  
  470.  
  471.  
  472.  
  473.  
  474.  
  475. /* Convert a string of 4 binary digits into an int */
  476.  
  477. static
  478. int
  479. bton (s)
  480.      char *s;
  481.  
  482. {
  483.   int n = 0;
  484.   int v = 8;
  485.   while (v)
  486.     {
  487.       if (*s == '1')
  488.     n |= v;
  489.       v >>= 1;
  490.       s++;
  491.     }
  492.   return n;
  493. }
  494.  
  495. static unsigned char table[1 << 16];
  496.  
  497. /* Take an opcode expand all varying fields in it out and fill all the
  498.   right entries in 'table' with the opcode index*/
  499.  
  500. static void
  501. expand_opcode (shift, val, i, s)
  502.      int shift;
  503.      int val;
  504.      int i;
  505.      char *s;
  506. {
  507.   int j;
  508.  
  509.   if (*s == 0)
  510.     {
  511.       table[val] = i;
  512.     }
  513.   else
  514.     {
  515.       switch (s[0])
  516.     {
  517.  
  518.     case '0':
  519.     case '1':
  520.       {
  521.  
  522.         int n = bton (s);
  523.         if (n >= 0)
  524.           {
  525.         expand_opcode (shift - 4, val | (n << shift), i, s + 4);
  526.           }
  527.         break;
  528.       }
  529.     case 'n':
  530.     case 'm':
  531.       for (j = 0; j < 16; j++)
  532.         {
  533.           expand_opcode (shift - 4, val | (j << shift), i, s + 4);
  534.  
  535.         }
  536.       break;
  537.  
  538.     default:
  539.       for (j = 0; j < (1 << (shift + 4)); j++)
  540.         {
  541.           table[val | j] = i;
  542.         }
  543.     }
  544.     }
  545. }
  546.  
  547. /* Print the jump table used to index an opcode into a switch
  548.    statement entry. */
  549.  
  550. static void
  551. dumptable ()
  552. {
  553.   int lump = 256;
  554.   int online = 16;
  555.  
  556.   int i = 0;
  557.  
  558.   while (i < 1 << 16)
  559.     {
  560.       int j = 0;
  561.  
  562.       printf ("unsigned char sh_jump_table%x[%d]={\n", i, lump);
  563.  
  564.       while (j < lump)
  565.     {
  566.       int k = 0;
  567.       while (k < online)
  568.         {
  569.           printf ("%2d", table[i + j + k]);
  570.           if (j + k < lump)
  571.         printf (",");
  572.  
  573.           k++;
  574.         }
  575.       j += k;
  576.       printf ("\n");
  577.     }
  578.       i += j;
  579.       printf ("};\n");
  580.     }
  581.  
  582. }
  583.  
  584.  
  585. static void
  586. filltable ()
  587. {
  588.   op *p;
  589.   int index = 1;
  590.  
  591.   sorttab ();
  592.   for (p = tab; p->name; p++)
  593.     {
  594.       p->index = index++;
  595.       expand_opcode (12, 0, p->index, p->code);
  596.     }
  597. }
  598.  
  599. static void
  600. gensim ()
  601. {
  602.   op *p;
  603.   int j;
  604.  
  605.   printf ("{\n");
  606.   printf ("switch (jump_table[iword]) {\n");
  607.  
  608.   for (p = tab; p->name; p++)
  609.     {
  610.       int sextbit = -1;
  611.       int needm = 0;
  612.       int needn = 0;
  613.       
  614.       char *s = p->code;
  615.  
  616.       printf ("\/\* %s %s *\/\n", p->name, p->code);
  617.       printf ("case %d:      \n", p->index);
  618.       
  619.       printf ("{\n");
  620.       while (*s)
  621.     {
  622.       switch (*s)
  623.         {
  624.         case '0':
  625.         case '1':
  626.         case '.':
  627.           s += 4;
  628.           break;
  629.         case 'n':
  630.           printf ("int n =  (iword >>8) & 0xf;\n");
  631.           needn = 1;
  632.           s += 4;
  633.           break;
  634.         case 'm':
  635.           printf ("int m =  (iword >>4) & 0xf;\n");
  636.           needm = 1;
  637.           s += 4;
  638.  
  639.           break;
  640.  
  641.         case 'i':
  642.           printf ("int i = (iword & 0x");
  643.  
  644.           switch (s[1])
  645.         {
  646.         case '4':
  647.           printf ("f");
  648.           break;
  649.         case '8':
  650.           printf ("ff");
  651.           break;
  652.         case '1':
  653.           sextbit = 12;
  654.  
  655.           printf ("fff");
  656.           break;
  657.         }
  658.           printf (")");
  659.  
  660.           switch (s[3])
  661.         {
  662.         case '1':
  663.           break;
  664.         case '2':
  665.           printf ("<<1");
  666.           break;
  667.         case '4':
  668.           printf ("<<2");
  669.           break;
  670.         }
  671.           printf (";\n");
  672.           s += 4;
  673.         }
  674.     }
  675.       if (sextbit > 0)
  676.     {
  677.       printf ("i = (i ^ (1<<%d))-(1<<%d);\n", sextbit - 1, sextbit - 1);
  678.     }
  679.       if (needm && needn)
  680.     printf("TB(m,n);");  
  681.       else if (needm)
  682.     printf("TL(m);");
  683.       else if (needn)
  684.     printf("TL(n);");
  685.       for (j = 0; j < 10; j++)
  686.     {
  687.       if (p->stuff[j])
  688.         {
  689.           printf ("%s\n", p->stuff[j]);
  690.         }
  691.     }
  692.       printf ("break;\n");
  693.       printf ("}\n");
  694.     }
  695.   printf ("}\n}\n");
  696. }
  697.  
  698.  
  699. int
  700. main (ac, av)
  701.      int ac;
  702.      char **av;
  703. {
  704.   if (ac > 1)
  705.     {
  706.       if (strcmp (av[1], "-t") == 0)
  707.     {
  708.       gengastab ();
  709.     }
  710.       else if (strcmp (av[1], "-s") == 0)
  711.     {
  712.       filltable ();
  713.       dumptable ();
  714.  
  715.     }
  716.       else if (strcmp (av[1], "-x") == 0)
  717.     {
  718.       filltable ();
  719.       gensim ();
  720.     }
  721.     }
  722.   else
  723.     {
  724.       genopc ();
  725.     }
  726.   return 0;
  727. }
  728.